Lambda the Ultimate

Realization of natural language interfaces using lazy functional programming, Richard Frost, ACM Computing Surveys, Volume 38, Issue 4 (2006).

The construction of natural language interfaces to computers continues to be a major challenge. The need for such interfaces is growing now that speech recognition technology is becoming more readily available, and people cannot speak those computer-oriented formal languages that are frequently used to interact with computer applications. Much of the research related to the design and implementation of natural language interfaces has involved the use of high-level declarative programming languages. This is to be expected as the task is extremely difficult, involving syntactic and semantic analysis of potentially ambiguous input. The use of LISP and Prolog in this area is well documented. However, research involving the relatively new lazy functional programming paradigm is less well known. This paper provides a comprehensive survey of that research.

When I heard of Amazon FPS (an overview of which can be found here), I knew a DSL must be hidden somewhere.

And indeed, the GateKeeper language is a special-purpose language for specifying (declarative) payment instructions.

Once again we see the importance of language design skills in today's marketplace...

So what do LtU readers think of the design of the GateKeeper language?

A friend of mine's asking for commentary on their project: The Karmasphere DP language

The Karmasphere DP language is a high-performance non-blocking
parallel language for performing data processing. It is designed
to give the user a high degree of control over the usage of system
resources, for example, how many CPU cores or how much disk I/O time
to use, without requiring the software developer to explicitly consider
these issues in code.

It was originally intended for collecting attributes of URLs and
domain names to be used in an anti-spam system, although it has since
developed into a full parallel programming language with many general
purpose operators.

It can take full advantage of multiprocessor (SMP or NUMA) systems,
and may be scaled sideways - since the interpreter and environment
are stateless, an entire cluster of machines may run the interpreter
in parallel without any requirement for synchronization.

In a quick conversation on IRC, the following was said:

Well, most people doing this kind of thing choose to play around with explicit continuations in the user language - which is totally technically correct, but from the user's point of view, impractical. Any language which requires a user to understand continuations or other theoretical concepts is the wrong answer. This language is designed to be simple to comprehend for the user who doesn't know anything about programming, even less parallelism.

Personally I find the relationship with GraphViz interesting.

edit: A demo is now available

The Yielder library by infomancers (a.k.a. Aviad Ben Dov of the Chaotic Java weblog) is a library providing Java with Ruby/Python/C#-like yield-ing for iterators.

It works by using Java 1.5's facility for hooking user-defined class inspectors/transformers into the classloader, and rewriting the bytecode of a yieldNextCore() method containing calls to yieldReturn(foo) so that its local variables are promoted to members of an anonymous inner class, which also maintains the state of the iterator/generator.

Examples, rationale and implementation are discussed in detail at Chaotic Java. There is also a collections library built on top of Yielder, with tree traversal iterators and map/filter-like functionality.

From a PL perspective, this ability to hook into the classloader and do bytecode manipulation on plain java classes provides an interesting mechanism for prototyping new language features in libraries. It could equally well support an aspect framework (via annotations), and perhaps even something like Terracotta's distributed heap.

Seven years ago today LtU was born. I find it incredible that we have been doing this for so long, that some of the earliest members are still here, and that some of the same topics are still going strong! While the range of topics and general style of LtU remained fairly constant over the years, each year brought with it its own flavour. The main reason for this was that LtU was always open to new members, and each contributing editor influenced the discussion according to his interests.

So how can one summarize year seven?

I think that for Anton and me year seven will be remembered as the year of spam. We have been fighting spam daily, and I fear that we will have to put in place more draconian measures on new users shortly. Some of you probably saw a couple of spam messages that managed to get past us. But let me assure you: this is a tiny fraction. There are hundreds of new users that signed up only to post spam, with at least two or three new spammers signing up daily. Since we try to accommodate new members, I am not deleting users that fail to comply with our request for real names or identifying personal information - and so detecting potential spammers before they begin posting spam is difficult and time consuming. One reason why I posted fewer programming language related posts was that I was simply too busy fighting spam...

This is a good opportunity to thank Anton again for all he does to keep LtU up and running ( his insightful and amusing posts I take for granted, you see). Without his help in putting in place the technical infrastructure required for all the spam monitoring and control we would have drowned in spam long ago. This is one reason (aside from the fact that I was very busy with other things) that year seven is (still) not the Year of the Wiki. We put up a wiki, but decided that the integration of the wiki into LtU would require too much time, time both us couldn't spend this year.

Spam came to LtU for the simple reason that LtU became too well known a site... In fact the second thing that happened to LtU this year is that the number of active members grew considerably. This is, of course, very gratifying. I still remember the early days, when LtU had three members, and we didn't know if between the three of us we can keep finding enough interesting material to keep the site alive.

As one might expect this meant that some topics that were discussed here many times came up for discussion again. It is good to revisit these issues from time to time, but I fear that the rising volume of messages, and the number of new users, some of whom with less decorum than others, kept many old timers from engaging in these discussions, leading to some long threads that were not up to the usual quality of LtU discussions. Since no one was there to object, some may have gotten the impression that these threads (replete with ad hominem attacks, insults and language advocacy) are acceptable on LtU. I am partly to blame for not stepping in, but I just didn't have the time to follow all these discussions. So let me take this opportunity to remind everyone that discussions of this type are not welcome by the LtU community, and suggest more recent members consult the LtU policy as well as the LtU spirit pages. We discussed various forms of moderation and control in the past, and I still think the conclusion we reached - that is that the community should "police" itself - is the right one. If you find the content or style objectionable, post about it (in a separate thread, if needed).

I noticed that several of the LtU contributing editors began to post less and less. While I think the items on the home page are
interesting and exciting, there are fewer new home page items each week than I'd like. One reason for this is that many prefer to post things on their own blogs, and a fair amount of LtU candidate material gets posted to places like programming.reddit.com. While there are LtU members who prefer to keep the site restricted as much as possible to the discussion of published academic papers, my opinion is that if a regular member considers some project, site or presentation to be of interest to the LtU community, he should post about it here. This is even truer when it comes to contributing editors, of course. Contributing editors - don't hesitate, contribute! I remind everyone that we have some departments that are begging for stories, top among them the new departments devoted to Scala and Ruby.

It seems to me that LtU is in a state of transition. We can fight to remain the LtU we all know and love - but this requires effort. Or we can hope for the best, and see LtU turn into comp.lang.misc. To make sure we don't jump the shark, the community has to step up. Both in terms of steering the conversation, and keeping threads from getting long and disorganized, and by posting new and interesting stuff!

This is a good opportunity to ask long time members to mentor new members, not just direct them to the getting started page :-) . I implore old timers that are sitting back to engage in the conversation, and let us know what they are up to. We miss you guys!
And most of all, I pray for spammers to just crawl back to where they came from.

The last wish, I know, is unlikely to happen. The others I think are within our reach!

Happy birthday everyone!

Comprehensive Comprehensions, Phil Wadler and Simon Peyton Jones

"The new constructs proposed here are more general than the constructs in the other languages, because they work with any function of a given type, rather than being limited to specific functions. Parametricity of these functions plays an important role in ensuring the semantics of such constructs is independent of particular details of how tuples of bindings are represented."

Liskell is Haskell on the inside but looks like Lisp on the outside, as in its source code it uses the typical Lisp syntax forms, namely symbol expressions, that are distinguished by their fully parenthesized prefix notation form. Liskell captures the most Haskell syntax forms in this prefix notation form.

Liskell is descreibed in an ILC paper. It is implemented as an extension to GHC.

Lambda is an interactive, graphical, pedagogical computer program that helps students of formal semantics practice the typed lambda calculus.

We discussed how the LC is used in linguistics in the past (check the archives). This tool may be useful even for those not interested in this angle, even though that's the intended use of the software.

One of the great things about LtU discussions is that we have some very witty posters, and some posts are LOL funny (that's "laugh out loud" for those new to the internet...)

So I decided to start an informal poll here: which is the funniest post on LtU ever?

I suggest two categories: one for general humour and wit, and a second for humour that requires knowledge of the theory of pogramming languages to decipher.

On edit: I think we need a special category for longer, more literary posts, if you will - the type Frank used to produce.

A short interview with Joe Armstrong about Erlang (naturally):

Ericsson has always used parallel hardware in its switching products -- right from the AXE in the mid 1970s. There is a "school" of parallel programming inside Ericsson. Erlang is the third language in a progression of languages: PLEX -> Eri-Pascal -> Erlang.